Add reflection configuration for Actuator Endpoints

This commit registers the necessary reflection configuration to be able
to invoke operation methods via reflection. Both endpoints and endpoint
extensions are supported.

Closes gh-999

Author: snicoll

spring-aot/pom.xml

@@ -43,6 +43,11 @@
 			<artifactId>spring-web</artifactId>
 			<optional>true</optional>
 		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-actuator</artifactId>
+			<optional>true</optional>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-autoconfigure</artifactId>

spring-aot/src/main/java/org/springframework/boot/actuate/endpoint/annotation/EndpointNativeConfigurationProcessor.java

@@ -0,0 +1,69 @@
+package org.springframework.boot.actuate.endpoint.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.context.bootstrap.generator.infrastructure.nativex.BeanFactoryNativeConfigurationProcessor;
+import org.springframework.context.bootstrap.generator.infrastructure.nativex.NativeConfigurationRegistry;
+import org.springframework.context.bootstrap.generator.infrastructure.nativex.NativeReflectionEntry.Builder;
+import org.springframework.core.annotation.MergedAnnotations;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.ReflectionUtils;
+
+/**
+ * A {@link BeanFactoryNativeConfigurationProcessor} that register reflection access for
+ * actuator endpoints, specifically the methods flagged with one of the supported
+ * operation annotations.
+ *
+ * @author Stephane Nicoll
+ */
+class EndpointNativeConfigurationProcessor implements BeanFactoryNativeConfigurationProcessor {
+
+	private static final String ENDPOINT_CLASS_NAME = "org.springframework.boot.actuate.endpoint.annotation.Endpoint";
+
+	@Override
+	public void process(ConfigurableListableBeanFactory beanFactory, NativeConfigurationRegistry registry) {
+		if (ClassUtils.isPresent(ENDPOINT_CLASS_NAME, beanFactory.getBeanClassLoader())) {
+			new Processor().process(beanFactory, registry);
+		}
+	}
+
+	private static class Processor {
+
+		private static final List<Class<? extends Annotation>> ENDPOINT_ANNOTATIONS = List.of(
+				Endpoint.class, EndpointExtension.class);
+
+		private static final List<Class<? extends Annotation>> OPERATION_ANNOTATIONS = List.of(
+				ReadOperation.class, WriteOperation.class, DeleteOperation.class);
+
+		void process(ConfigurableListableBeanFactory beanFactory, NativeConfigurationRegistry registry) {
+			findCandidates(beanFactory).forEach((beanName, endpoint) -> registerEndpoint(registry, endpoint));
+		}
+
+		private Map<String, Class<?>> findCandidates(ConfigurableListableBeanFactory beanFactory) {
+			Map<String, Class<?>> candidates = new LinkedHashMap<>();
+			ENDPOINT_ANNOTATIONS.forEach((annotation) -> {
+				String[] beanNames = beanFactory.getBeanNamesForAnnotation(annotation);
+				for (String beanName : beanNames) {
+					candidates.put(beanName, beanFactory.getType(beanName));
+				}
+			});
+			return candidates;
+		}
+
+		private void registerEndpoint(NativeConfigurationRegistry registry, Class<?> type) {
+			Builder builder = registry.reflection().forType(type);
+			ReflectionUtils.doWithMethods(type, builder::withMethods, this::isOperationMethod);
+		}
+
+		private boolean isOperationMethod(Method method) {
+			MergedAnnotations from = MergedAnnotations.from(method);
+			return OPERATION_ANNOTATIONS.stream().anyMatch(from::isPresent);
+		}
+	}
+
+}

spring-aot/src/main/resources/META-INF/spring.factories

@@ -9,6 +9,7 @@ org.springframework.boot.context.properties.ConfigurationPropertiesBeanRegistrat
 org.springframework.context.bootstrap.generator.bean.DefaultBeanRegistrationWriterSupplier
 
 org.springframework.context.bootstrap.generator.infrastructure.nativex.BeanFactoryNativeConfigurationProcessor=\
+org.springframework.boot.actuate.endpoint.annotation.EndpointNativeConfigurationProcessor,\
 org.springframework.boot.context.properties.ConfigurationPropertiesNativeConfigurationProcessor
 
 org.springframework.context.bootstrap.generator.infrastructure.nativex.BeanNativeConfigurationProcessor=\

spring-aot/src/test/java/org/springframework/boot/actuate/endpoint/annotation/EndpointNativeConfigurationProcessorTests.java

@@ -0,0 +1,103 @@
+package org.springframework.boot.actuate.endpoint.annotation;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.boot.actuate.endpoint.web.annotation.EndpointWebExtension;
+import org.springframework.context.bootstrap.generator.infrastructure.nativex.NativeConfigurationRegistry;
+import org.springframework.context.bootstrap.generator.infrastructure.nativex.NativeReflectionEntry;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link EndpointNativeConfigurationProcessor}.
+ *
+ * @author Stephane Nicoll
+ */
+class EndpointNativeConfigurationProcessorTests {
+
+	@Test
+	void registerSimpleEndpoint() {
+		DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
+		beanFactory.registerBeanDefinition("noise", BeanDefinitionBuilder.rootBeanDefinition(String.class).getBeanDefinition());
+		beanFactory.registerBeanDefinition("endpoint", BeanDefinitionBuilder.rootBeanDefinition(TestEndpoint.class).getBeanDefinition());
+		NativeConfigurationRegistry registry = process(beanFactory);
+		List<NativeReflectionEntry> entries = registry.reflection().getEntries();
+		assertThat(entries).anySatisfy((entry) -> {
+			assertThat(entry.getType()).isEqualTo(TestEndpoint.class);
+			assertThat(entry.getMethods().stream().map(Method::getName))
+					.containsOnly("getAll", "get", "set", "delete");
+		});
+		assertThat(entries).hasSize(1);
+	}
+
+	@Test
+	void registerSimpleEndpointExtension() {
+		DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
+		beanFactory.registerBeanDefinition("noise", BeanDefinitionBuilder.rootBeanDefinition(String.class).getBeanDefinition());
+		beanFactory.registerBeanDefinition("endpoint", BeanDefinitionBuilder.rootBeanDefinition(TestEndpointWebExtension.class).getBeanDefinition());
+		NativeConfigurationRegistry registry = process(beanFactory);
+		List<NativeReflectionEntry> entries = registry.reflection().getEntries();
+		assertThat(entries).anySatisfy((entry) -> {
+			assertThat(entry.getType()).isEqualTo(TestEndpointWebExtension.class);
+			assertThat(entry.getMethods().stream().map(Method::getName)).containsOnly("get");
+		});
+		assertThat(entries).hasSize(1);
+	}
+
+	private NativeConfigurationRegistry process(DefaultListableBeanFactory beanFactory) {
+		NativeConfigurationRegistry registry = new NativeConfigurationRegistry();
+		new EndpointNativeConfigurationProcessor().process(beanFactory, registry);
+		return registry;
+	}
+
+	@Endpoint(id = "test")
+	@SuppressWarnings("unused")
+	static class TestEndpoint {
+
+		@ReadOperation
+		public List<String> getAll() {
+			return List.of(get());
+		}
+
+		@ReadOperation
+		public String get() {
+			return "test";
+		}
+
+		@WriteOperation
+		public void set(String name) {
+
+		}
+
+		@DeleteOperation
+		public void delete(String name) {
+
+		}
+
+		public void ignoredMethod(String name) {
+
+		}
+
+	}
+
+	@EndpointWebExtension(endpoint = TestEndpoint.class)
+	@SuppressWarnings("unused")
+	static class TestEndpointWebExtension {
+
+		@ReadOperation
+		public String get() {
+			return "web";
+		}
+
+		public void noise(String name) {
+
+		}
+
+	}
+
+}