Improve @ConditionalOnEnabledEndpoint to be used on any component

This commit adds an `endpoint` attribute so that the condition can be
used on arbitrary components, not only endpoints or extensions.

Closes spring-projectsgh-12945

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/endpoint/condition/ConditionalOnEnabledEndpoint.java

@@ -31,6 +31,60 @@
  * according to the endpoints specific {@link Environment} property, falling back to
  * {@code management.endpoints.enabled-by-default} or failing that
  * {@link Endpoint#enableByDefault()}.
+ * <p>
+ * When placed on a {@code @Bean} method, the endpoint defaults to the return type of the
+ * factory method:
+ *
+ * <pre class="code">
+ * &#064;Configuration
+ * public class MyConfiguration {
+ *
+ *     &#064;ConditionalOnEnableEndpoint
+ *     &#064;Bean
+ *     public MyEndpoint myEndpoint() {
+ *         ...
+ *     }
+ *
+ * }</pre>
+ * <p>
+ * It is also possible to use the same mechanism for extensions:
+ *
+ * <pre class="code">
+ * &#064;Configuration
+ * public class MyConfiguration {
+ *
+ *     &#064;ConditionalOnEnableEndpoint
+ *     &#064;Bean
+ *     public MyEndpointWebExtension myEndpointWebExtension() {
+ *         ...
+ *     }
+ *
+ * }</pre>
+ * <p>
+ * In the sample above, {@code MyEndpointWebExtension} will be created if the endpoint is
+ * enabled as defined by the rules above. {@code MyEndpointWebExtension} must be a regular
+ * extension that refers to an endpoint, something like:
+ *
+ * <pre class="code">
+ * &#064;EndpointWebExtension(endpoint = MyEndpoint.class)
+ * class MyEndpointWebExtension {
+ *
+ * }</pre>
+ * <p>
+ * Alternatively, the target endpoint can be manually specified for components that should
+ * only be created when a given endpoint is enabled:
+ *
+ * <pre class="code">
+ * &#064;Configuration
+ * public class MyConfiguration {
+ *
+ *     &#064;ConditionalOnEnableEndpoint(endpoint = MyEndpoint.class)
+ *     &#064;Bean
+ *     public MyComponent myComponent() {
+ *         ...
+ *     }
+ *
+ * }</pre>
  *
  * @author Stephane Nicoll
  * @since 2.0.0
@@ -42,4 +96,12 @@
 @Conditional(OnEnabledEndpointCondition.class)
 public @interface ConditionalOnEnabledEndpoint {
 
+	/**
+	 * The endpoint type that should be checked. Inferred when the condition is placed
+	 * on {@code @Bean} methods.
+	 * @return the endpoint type to check
+	 * @since 2.1.0
+	 */
+	Class<?> endpoint() default Endpoint.class;
+
 }

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/endpoint/condition/OnEnabledEndpointCondition.java

@@ -16,6 +16,7 @@
 
 package org.springframework.boot.actuate.autoconfigure.endpoint.condition;
 
+import java.util.Map;
 import java.util.Optional;
 
 import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
@@ -92,16 +93,24 @@ private AnnotationAttributes getEndpointAttributes(ConditionContext context,
 				metadata instanceof MethodMetadata
 						&& metadata.isAnnotated(Bean.class.getName()),
 				"OnEnabledEndpointCondition may only be used on @Bean methods");
-		return getEndpointAttributes(context, (MethodMetadata) metadata);
+		Class<?> endpointType = getEndpointType(context, (MethodMetadata) metadata);
+		return getEndpointAttributes(endpointType);
 	}
 
-	private AnnotationAttributes getEndpointAttributes(ConditionContext context,
+	private Class<?> getEndpointType(ConditionContext context,
 			MethodMetadata metadata) {
+		Map<String, Object> attributes = metadata.getAnnotationAttributes(
+				ConditionalOnEnabledEndpoint.class.getName());
+		if (attributes != null && attributes.containsKey("endpoint")) {
+			Class<?> target = (Class<?>) attributes.get("endpoint");
+			if (target != Endpoint.class) {
+				return target;
+			}
+		}
 		// We should be safe to load at this point since we are in the REGISTER_BEAN phase
 		try {
-			Class<?> returnType = ClassUtils.forName(metadata.getReturnTypeName(),
+			return ClassUtils.forName(metadata.getReturnTypeName(),
 					context.getClassLoader());
-			return getEndpointAttributes(returnType);
 		}
 		catch (Throwable ex) {
 			throw new IllegalStateException("Failed to extract endpoint id for "
@@ -119,8 +128,8 @@ protected AnnotationAttributes getEndpointAttributes(Class<?> type) {
 		attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(type,
 				EndpointExtension.class, false, true);
 		Assert.state(attributes != null,
-				"OnEnabledEndpointCondition may only be used on @Bean methods that "
-						+ "return an @Endpoint or @EndpointExtension");
+				"No endpoint is specified and the return type of the @Bean method is "
+						+ "neither an @Endpoint, nor an @EndpointExtension");
 		return getEndpointAttributes(attributes.getClass("endpoint"));
 	}
 

spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/endpoint/condition/ConditionalOnEnabledEndpointTests.java

@@ -102,6 +102,43 @@ public void outcomeWhenNoPropertiesAndExtensionAnnotationIsNotEnabledByDefaultSh
 						.doesNotHaveBean("fooExt"));
 	}
 
+	@Test
+	public void outcomeWithReferenceWhenNoPropertiesShouldMatch() {
+		this.contextRunner.withUserConfiguration(FooEndpointEnabledByDefaultTrue.class,
+				ComponentEnabledIfEndpointIsEnabledConfiguration.class).run((context) ->
+			assertThat(context).hasBean("fooComponent"));
+	}
+
+	@Test
+	public void outcomeWithReferenceWhenEndpointEnabledPropertyIsTrueShouldMatch() {
+		this.contextRunner.withPropertyValues("management.endpoint.foo.enabled=true")
+				.withUserConfiguration(FooEndpointEnabledByDefaultTrue.class,
+						ComponentEnabledIfEndpointIsEnabledConfiguration.class)
+				.run((context) ->
+						assertThat(context).hasBean("fooComponent"));
+	}
+
+	@Test
+	public void outcomeWithReferenceWhenEndpointEnabledPropertyIsFalseShouldNotMatch() {
+		this.contextRunner.withPropertyValues("management.endpoint.foo.enabled=false")
+				.withUserConfiguration(FooEndpointEnabledByDefaultTrue.class,
+						ComponentEnabledIfEndpointIsEnabledConfiguration.class)
+				.run((context) ->
+						assertThat(context).doesNotHaveBean("fooComponent"));
+	}
+
+	@Test
+	public void outcomeWithNoReferenceShouldFail() {
+		this.contextRunner.withUserConfiguration(
+				ComponentWithNoEndpointReferenceConfiguration.class).run((context) -> {
+			assertThat(context).hasFailed();
+			assertThat(context.getStartupFailure().getCause().getMessage()).contains(
+					"No endpoint is specified and the return type of the @Bean method "
+							+ "is neither an @Endpoint, nor an @EndpointExtension");
+		});
+	}
+
+
 	@Endpoint(id = "foo", enableByDefault = true)
 	static class FooEndpointEnabledByDefaultTrue {
 
@@ -187,4 +224,26 @@ public FooEndpointExtensionEnabledByDefaultFalse fooExt() {
 
 	}
 
+	@Configuration
+	static class ComponentEnabledIfEndpointIsEnabledConfiguration {
+
+		@Bean
+		@ConditionalOnEnabledEndpoint(endpoint = FooEndpointEnabledByDefaultTrue.class)
+		public String fooComponent() {
+			return "foo";
+		}
+
+	}
+
+	@Configuration
+	static class ComponentWithNoEndpointReferenceConfiguration {
+
+		@Bean
+		@ConditionalOnEnabledEndpoint
+		public String fooComponent() {
+			return "foo";
+		}
+
+	}
+
 }