Make auto-configurations final and remove public members

Closes gh-32883

Author: mhalbritter

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

@@ -22,17 +22,22 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.function.BiConsumer;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import com.tngtech.archunit.base.DescribedPredicate;
 import com.tngtech.archunit.core.domain.AccessTarget.CodeUnitCallTarget;
 import com.tngtech.archunit.core.domain.JavaAnnotation;
 import com.tngtech.archunit.core.domain.JavaCall;
 import com.tngtech.archunit.core.domain.JavaClass;
 import com.tngtech.archunit.core.domain.JavaClass.Predicates;
+import com.tngtech.archunit.core.domain.JavaConstructor;
+import com.tngtech.archunit.core.domain.JavaField;
+import com.tngtech.archunit.core.domain.JavaMember;
 import com.tngtech.archunit.core.domain.JavaMethod;
 import com.tngtech.archunit.core.domain.JavaModifier;
 import com.tngtech.archunit.core.domain.JavaParameter;
@@ -68,6 +73,8 @@
  */
 final class ArchitectureRules {
 
+	private static final String AUTOCONFIGURATION_ANNOTATION = "org.springframework.boot.autoconfigure.AutoConfiguration";
+
 	private ArchitectureRules() {
 	}
 
@@ -98,6 +105,8 @@ static List<ArchRule> standard() {
 		rules.add(methodLevelConfigurationPropertiesShouldNotSpecifyOnlyPrefixAttribute());
 		rules.add(conditionsShouldNotBePublic());
 		rules.add(allConfigurationPropertiesBindingBeanMethodsShouldBeStatic());
+		rules.add(autoConfigurationClassesShouldBePublicAndFinal());
+		rules.add(autoConfigurationClassesShouldHaveNoPublicMembers());
 		return List.copyOf(rules);
 	}
 
@@ -319,6 +328,63 @@ private static ArchRule allConfigurationPropertiesBindingBeanMethodsShouldBeStat
 			.allowEmptyShould(true);
 	}
 
+	private static ArchRule autoConfigurationClassesShouldBePublicAndFinal() {
+		return ArchRuleDefinition.classes()
+			.that()
+			.areAnnotatedWith(AUTOCONFIGURATION_ANNOTATION)
+			.should()
+			.bePublic()
+			.andShould()
+			.haveModifier(JavaModifier.FINAL)
+			.allowEmptyShould(true);
+	}
+
+	private static ArchRule autoConfigurationClassesShouldHaveNoPublicMembers() {
+		return ArchRuleDefinition.members()
+			.that()
+			.areDeclaredInClassesThat()
+			.areAnnotatedWith(AUTOCONFIGURATION_ANNOTATION)
+			.and(areNotDefaultConstructors())
+			.and(areNotConstants())
+			.and(dontOverridePublicMethods())
+			.should()
+			.notBePublic()
+			.allowEmptyShould(true);
+	}
+
+	private static DescribedPredicate<? super JavaMember> dontOverridePublicMethods() {
+		OverridesPublicMethod<JavaMember> predicate = new OverridesPublicMethod<>();
+		return DescribedPredicate.describe("don't override public methods", (member) -> !predicate.test(member));
+	}
+
+	private static DescribedPredicate<JavaMember> areNotDefaultConstructors() {
+		return DescribedPredicate.describe("aren't default constructors",
+				(member) -> !areDefaultConstructors().test(member));
+	}
+
+	private static DescribedPredicate<JavaMember> areDefaultConstructors() {
+		return DescribedPredicate.describe("are default constructors", (member) -> {
+			if (!(member instanceof JavaConstructor constructor)) {
+				return false;
+			}
+			return constructor.getParameters().isEmpty();
+		});
+	}
+
+	private static DescribedPredicate<JavaMember> areNotConstants() {
+		return DescribedPredicate.describe("aren't constants", (member) -> !areConstants().test(member));
+	}
+
+	private static DescribedPredicate<JavaMember> areConstants() {
+		return DescribedPredicate.describe("are constants", (member) -> {
+			if (member instanceof JavaField field) {
+				Set<JavaModifier> modifiers = field.getModifiers();
+				return modifiers.contains(JavaModifier.STATIC) && modifiers.contains(JavaModifier.FINAL);
+			}
+			return false;
+		});
+	}
+
 	private static boolean containsOnlySingleType(JavaType[] types, JavaType type) {
 		return types.length == 1 && type.equals(types[0]);
 	}
@@ -391,4 +457,39 @@ private static String shouldUse(String string) {
 		return string + " should be used instead";
 	}
 
+	private static class OverridesPublicMethod<T extends JavaMember> extends DescribedPredicate<T> {
+
+		OverridesPublicMethod() {
+			super("overrides public method");
+		}
+
+		@Override
+		public boolean test(T member) {
+			if (!(member instanceof JavaMethod javaMethod)) {
+				return false;
+			}
+			Stream<JavaMethod> superClassMethods = member.getOwner()
+				.getAllRawSuperclasses()
+				.stream()
+				.flatMap((superClass) -> superClass.getMethods().stream());
+			Stream<JavaMethod> interfaceMethods = member.getOwner()
+				.getAllRawInterfaces()
+				.stream()
+				.flatMap((iface) -> iface.getMethods().stream());
+			return Stream.concat(superClassMethods, interfaceMethods)
+				.anyMatch((superMethod) -> isPublic(superMethod) && isOverridden(superMethod, javaMethod));
+		}
+
+		private boolean isPublic(JavaMethod method) {
+			return method.getModifiers().contains(JavaModifier.PUBLIC);
+		}
+
+		private boolean isOverridden(JavaMethod superMethod, JavaMethod method) {
+			return superMethod.getName().equals(method.getName())
+					&& superMethod.getRawParameterTypes().size() == method.getRawParameterTypes().size()
+					&& superMethod.getDescriptor().equals(method.getDescriptor());
+		}
+
+	}
+
 }

core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/admin/SpringApplicationAdminJmxAutoConfiguration.java

@@ -40,7 +40,7 @@
  */
 @AutoConfiguration(after = JmxAutoConfiguration.class)
 @ConditionalOnBooleanProperty("spring.application.admin.enabled")
-public class SpringApplicationAdminJmxAutoConfiguration {
+public final class SpringApplicationAdminJmxAutoConfiguration {
 
 	/**
 	 * The property to use to customize the {@code ObjectName} of the application admin
@@ -55,8 +55,8 @@ public class SpringApplicationAdminJmxAutoConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
-	public SpringApplicationAdminMXBeanRegistrar springApplicationAdminRegistrar(
-			ObjectProvider<MBeanExporter> mbeanExporters, Environment environment) throws MalformedObjectNameException {
+	SpringApplicationAdminMXBeanRegistrar springApplicationAdminRegistrar(ObjectProvider<MBeanExporter> mbeanExporters,
+			Environment environment) throws MalformedObjectNameException {
 		String jmxName = environment.getProperty(JMX_NAME_PROPERTY, DEFAULT_JMX_NAME);
 		if (mbeanExporters != null) { // Make sure to not register that MBean twice
 			for (MBeanExporter mbeanExporter : mbeanExporters) {

core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/aop/AopAutoConfiguration.java

@@ -45,7 +45,7 @@
  */
 @AutoConfiguration
 @ConditionalOnBooleanProperty(name = "spring.aop.auto", matchIfMissing = true)
-public class AopAutoConfiguration {
+public final class AopAutoConfiguration {
 
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnClass(Advice.class)

core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/availability/ApplicationAvailabilityAutoConfiguration.java

@@ -31,11 +31,11 @@
  * @since 2.3.0
  */
 @AutoConfiguration
-public class ApplicationAvailabilityAutoConfiguration {
+public final class ApplicationAvailabilityAutoConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean(ApplicationAvailability.class)
-	public ApplicationAvailabilityBean applicationAvailability() {
+	ApplicationAvailabilityBean applicationAvailability() {
 		return new ApplicationAvailabilityBean();
 	}
 

core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/context/ConfigurationPropertiesAutoConfiguration.java

@@ -33,6 +33,6 @@
  */
 @AutoConfiguration
 @EnableConfigurationProperties
-public class ConfigurationPropertiesAutoConfiguration {
+public final class ConfigurationPropertiesAutoConfiguration {
 
 }

core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/context/LifecycleAutoConfiguration.java

@@ -34,12 +34,12 @@
  */
 @AutoConfiguration
 @EnableConfigurationProperties(LifecycleProperties.class)
-public class LifecycleAutoConfiguration {
+public final class LifecycleAutoConfiguration {
 
 	@Bean(name = AbstractApplicationContext.LIFECYCLE_PROCESSOR_BEAN_NAME)
 	@ConditionalOnMissingBean(name = AbstractApplicationContext.LIFECYCLE_PROCESSOR_BEAN_NAME,
 			search = SearchStrategy.CURRENT)
-	public DefaultLifecycleProcessor defaultLifecycleProcessor(LifecycleProperties properties) {
+	DefaultLifecycleProcessor defaultLifecycleProcessor(LifecycleProperties properties) {
 		DefaultLifecycleProcessor lifecycleProcessor = new DefaultLifecycleProcessor();
 		lifecycleProcessor.setTimeoutPerShutdownPhase(properties.getTimeoutPerShutdownPhase().toMillis());
 		return lifecycleProcessor;

core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/context/MessageSourceAutoConfiguration.java

@@ -68,12 +68,12 @@
 @Conditional(ResourceBundleCondition.class)
 @EnableConfigurationProperties(MessageSourceProperties.class)
 @ImportRuntimeHints(MessageSourceRuntimeHints.class)
-public class MessageSourceAutoConfiguration {
+public final class MessageSourceAutoConfiguration {
 
 	private static final Resource[] NO_RESOURCES = {};
 
 	@Bean
-	public MessageSource messageSource(MessageSourceProperties properties) {
+	MessageSource messageSource(MessageSourceProperties properties) {
 		ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
 		if (!CollectionUtils.isEmpty(properties.getBasename())) {
 			messageSource.setBasenames(properties.getBasename().toArray(new String[0]));

core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/context/PropertyPlaceholderAutoConfiguration.java

@@ -35,11 +35,11 @@
  */
 @AutoConfiguration
 @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
-public class PropertyPlaceholderAutoConfiguration {
+public final class PropertyPlaceholderAutoConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean(search = SearchStrategy.CURRENT)
-	public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
+	static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
 		return new PropertySourcesPlaceholderConfigurer();
 	}
 

core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/info/ProjectInfoAutoConfiguration.java

@@ -49,26 +49,26 @@
  */
 @AutoConfiguration
 @EnableConfigurationProperties(ProjectInfoProperties.class)
-public class ProjectInfoAutoConfiguration {
+public final class ProjectInfoAutoConfiguration {
 
 	private final ProjectInfoProperties properties;
 
-	public ProjectInfoAutoConfiguration(ProjectInfoProperties properties) {
+	ProjectInfoAutoConfiguration(ProjectInfoProperties properties) {
 		this.properties = properties;
 	}
 
 	@Conditional(GitResourceAvailableCondition.class)
 	@ConditionalOnMissingBean
 	@Bean
-	public GitProperties gitProperties() throws Exception {
+	GitProperties gitProperties() throws Exception {
 		return new GitProperties(
 				loadFrom(this.properties.getGit().getLocation(), "git", this.properties.getGit().getEncoding()));
 	}
 
 	@ConditionalOnResource(resources = "${spring.info.build.location:classpath:META-INF/build-info.properties}")
 	@ConditionalOnMissingBean
 	@Bean
-	public BuildProperties buildProperties() throws Exception {
+	BuildProperties buildProperties() throws Exception {
 		return new BuildProperties(
 				loadFrom(this.properties.getBuild().getLocation(), "build", this.properties.getBuild().getEncoding()));
 	}

core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jmx/JmxAutoConfiguration.java

@@ -53,18 +53,18 @@
 @EnableConfigurationProperties(JmxProperties.class)
 @ConditionalOnClass({ MBeanExporter.class })
 @ConditionalOnBooleanProperty("spring.jmx.enabled")
-public class JmxAutoConfiguration {
+public final class JmxAutoConfiguration {
 
 	private final JmxProperties properties;
 
-	public JmxAutoConfiguration(JmxProperties properties) {
+	JmxAutoConfiguration(JmxProperties properties) {
 		this.properties = properties;
 	}
 
 	@Bean
 	@Primary
 	@ConditionalOnMissingBean(value = MBeanExporter.class, search = SearchStrategy.CURRENT)
-	public AnnotationMBeanExporter mbeanExporter(ObjectNamingStrategy namingStrategy, BeanFactory beanFactory) {
+	AnnotationMBeanExporter mbeanExporter(ObjectNamingStrategy namingStrategy, BeanFactory beanFactory) {
 		AnnotationMBeanExporter exporter = new AnnotationMBeanExporter();
 		exporter.setRegistrationPolicy(this.properties.getRegistrationPolicy());
 		exporter.setNamingStrategy(namingStrategy);
@@ -78,7 +78,7 @@ public AnnotationMBeanExporter mbeanExporter(ObjectNamingStrategy namingStrategy
 
 	@Bean
 	@ConditionalOnMissingBean(value = ObjectNamingStrategy.class, search = SearchStrategy.CURRENT)
-	public ParentAwareNamingStrategy objectNamingStrategy() {
+	ParentAwareNamingStrategy objectNamingStrategy() {
 		ParentAwareNamingStrategy namingStrategy = new ParentAwareNamingStrategy(new AnnotationJmxAttributeSource());
 		String defaultDomain = this.properties.getDefaultDomain();
 		if (StringUtils.hasLength(defaultDomain)) {
@@ -90,7 +90,7 @@ public ParentAwareNamingStrategy objectNamingStrategy() {
 
 	@Bean
 	@ConditionalOnMissingBean
-	public MBeanServer mbeanServer() {
+	MBeanServer mbeanServer() {
 		MBeanServerFactoryBean factory = new MBeanServerFactoryBean();
 		factory.setLocateExistingServerIfPossible(true);
 		factory.afterPropertiesSet();