Provide an API to record various runtime hints

This commit provides an API to record the need for reflection,
resources, serialization, and proxies so that the runtime can be
optimized accordingly.

`RuntimeHints` provides an entry point to register the following:

* Reflection hints: individual elements of a type can be defined, as
well as a predefined categories (identified by the `MemberCategory`
enum). A method or constructor hint can refine whether the executable
should only be introspected or also invoked.
* Resource hints: patterns using includes/excludes identify the
resources to include at runtime. Resource bundles are also supported.
* Java Serialization hints: types that use java serialization can be
registered.
* Proxy hints: both interfaces-based (JDK) proxy and class-based proxy
can be defined.

This commit also introduces a `TypeReference` abstraction that permits
to record hints for types that are not available on the classpath, or
not compiled yet (generated code).

Closes gh-27829

Author: snicoll

spring-core/src/main/java/org/springframework/core/hint/AbstractTypeReference.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2002-2022 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.core.hint;
+
+import java.util.Objects;
+
+/**
+ * Base {@link TypeReference} implementation that ensures consistent behaviour
+ * for {@code equals()}, {@code hashCode()}, and {@code toString()} based on
+ * the {@linkplain #getCanonicalName() canonical name}.
+ *
+ * @author Stephane Nicoll
+ * @since 6.0
+ */
+public abstract class AbstractTypeReference implements TypeReference {
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(getCanonicalName());
+	}
+
+	@Override
+	public boolean equals(Object other) {
+		if (this == other) {
+			return true;
+		}
+		if (!(other instanceof TypeReference otherReference)) {
+			return false;
+		}
+		return getCanonicalName().equals(otherReference.getCanonicalName());
+	}
+
+	@Override
+	public String toString() {
+		return getCanonicalName();
+	}
+
+}

spring-core/src/main/java/org/springframework/core/hint/ClassProxyHint.java

@@ -0,0 +1,141 @@
+/*
+ * Copyright 2002-2022 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.core.hint;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * A hint that describes the need for a proxy against a concrete class.
+ *
+ * @author Stephane Nicoll
+ * @since 6.0
+ */
+public final class ClassProxyHint {
+
+	private final TypeReference targetClass;
+
+	private final List<TypeReference> proxiedInterfaces;
+
+
+	private ClassProxyHint(Builder builder) {
+		this.targetClass = builder.targetClass;
+		this.proxiedInterfaces = builder.proxiedInterfaces.stream().distinct().toList();
+	}
+
+	/**
+	 * Initialize a builder with the target class to use.
+	 * @param targetClass the target class of the proxy
+	 * @return a builder for the hint
+	 */
+	public static Builder of(TypeReference targetClass) {
+		return new Builder(targetClass);
+	}
+
+	/**
+	 * Initialize a builder with the target class to use.
+	 * @param targetClass the target class of the proxy
+	 * @return a builder for the hint
+	 */
+	public static Builder of(Class<?> targetClass) {
+		return of(TypeReference.of(targetClass));
+	}
+
+	/**
+	 * Return the target class of the proxy.
+	 * @return the target class
+	 */
+	public TypeReference getTargetClass() {
+		return this.targetClass;
+	}
+
+	/**
+	 * Return the interfaces to be proxied.
+	 * @return the interfaces that the proxy should implement
+	 */
+	public List<TypeReference> getProxiedInterfaces() {
+		return this.proxiedInterfaces;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (o == null || getClass() != o.getClass()) {
+			return false;
+		}
+		ClassProxyHint that = (ClassProxyHint) o;
+		return this.targetClass.equals(that.targetClass)
+				&& this.proxiedInterfaces.equals(that.proxiedInterfaces);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(this.targetClass, this.proxiedInterfaces);
+	}
+
+
+	/**
+	 * Builder for {@link ClassProxyHint}.
+	 */
+	public static class Builder {
+
+		private final TypeReference targetClass;
+
+		private final LinkedList<TypeReference> proxiedInterfaces = new LinkedList<>();
+
+
+		public Builder(TypeReference targetClass) {
+			this.targetClass = targetClass;
+		}
+
+		/**
+		 * Add the specified interfaces that the proxy should implement.
+		 * @param proxiedInterfaces the interfaces the proxy should implement
+		 * @return {@code this}, to facilitate method chaining
+		 */
+		public Builder proxiedInterfaces(TypeReference... proxiedInterfaces) {
+			this.proxiedInterfaces.addAll(Arrays.asList(proxiedInterfaces));
+			return this;
+		}
+
+		/**
+		 * Add the specified interfaces that the proxy should implement.
+		 * @param proxiedInterfaces the interfaces the proxy should implement
+		 * @return {@code this}, to facilitate method chaining
+		 */
+		public Builder proxiedInterfaces(Class<?>... proxiedInterfaces) {
+			this.proxiedInterfaces.addAll(Arrays.stream(proxiedInterfaces)
+					.map(TypeReference::of).collect(Collectors.toList()));
+			return this;
+		}
+
+		/**
+		 * Create a {@link ClassProxyHint} based on the state of this builder.
+		 * @return a class proxy hint
+		 */
+		public ClassProxyHint build() {
+			return new ClassProxyHint(this);
+		}
+
+	}
+
+}

spring-core/src/main/java/org/springframework/core/hint/ExecutableHint.java

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2002-2022 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.core.hint;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.springframework.util.ObjectUtils;
+
+/**
+ * A hint that describes the need for reflection on a {@link Method} or
+ * {@link Constructor}.
+ *
+ * @author Stephane Nicoll
+ * @since 6.0
+ */
+public final class ExecutableHint extends MemberHint {
+
+	private final List<TypeReference> parameterTypes;
+
+	private final List<ExecutableMode> modes;
+
+
+	private ExecutableHint(Builder builder) {
+		super(builder.name);
+		this.parameterTypes = List.copyOf(builder.parameterTypes);
+		this.modes = List.copyOf(builder.modes);
+	}
+
+	/**
+	 * Initialize a builder with the parameter types of a constructor.
+	 * @param parameterTypes the parameter types of the constructor
+	 * @return a builder
+	 */
+	public static Builder ofConstructor(List<TypeReference> parameterTypes) {
+		return new Builder("<init>", parameterTypes);
+	}
+
+	/**
+	 * Initialize a builder with the name and parameters types of a method.
+	 * @param name the name of the method
+	 * @param parameterTypes the parameter types of the method
+	 * @return a builder
+	 */
+	public static Builder ofMethod(String name, List<TypeReference> parameterTypes) {
+		return new Builder(name, parameterTypes);
+	}
+
+	/**
+	 * Return the parameter types of the executable.
+	 * @return the parameter types
+	 * @see Executable#getParameterTypes()
+	 */
+	public List<TypeReference> getParameterTypes() {
+		return this.parameterTypes;
+	}
+
+	/**
+	 * Return the {@linkplain ExecutableMode modes} that apply to this hint.
+	 * @return the modes
+	 */
+	public List<ExecutableMode> getModes() {
+		return this.modes;
+	}
+
+
+	/**
+	 * Builder for {@link ExecutableHint}.
+	 */
+	public static final class Builder {
+
+		private final String name;
+
+		private final List<TypeReference> parameterTypes;
+
+		private final Set<ExecutableMode> modes = new LinkedHashSet<>();
+
+
+		private Builder(String name, List<TypeReference> parameterTypes) {
+			this.name = name;
+			this.parameterTypes = parameterTypes;
+		}
+
+		/**
+		 * Add the specified {@linkplain ExecutableMode mode} if necessary.
+		 * @param mode the mode to add
+		 * @return {@code this}, to facilitate method chaining
+		 */
+		public Builder withMode(ExecutableMode mode) {
+			this.modes.add(mode);
+			return this;
+		}
+
+		/**
+		 * Set the {@linkplain ExecutableMode modes} to use.
+		 * @param modes the mode to use
+		 * @return {@code this}, to facilitate method chaining
+		 */
+		public Builder setModes(ExecutableMode... modes) {
+			this.modes.clear();
+			if (!ObjectUtils.isEmpty(modes)) {
+				this.modes.addAll(Arrays.asList(modes));
+			}
+			return this;
+		}
+
+		/**
+		 * Create an {@link ExecutableHint} based on the state of this builder.
+		 * @return an executable hint
+		 */
+		public ExecutableHint build() {
+			return new ExecutableHint(this);
+		}
+
+	}
+
+}

spring-core/src/main/java/org/springframework/core/hint/ExecutableMode.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2002-2022 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.core.hint;
+
+import java.lang.reflect.Executable;
+
+/**
+ * Represent the need of reflection for a given {@link Executable}.
+ *
+ * @author Stephane Nicoll
+ * @since 6.0
+ */
+public enum ExecutableMode {
+
+	/**
+	 * Only retrieving the {@link Executable} and its metadata is required.
+	 */
+	INTROSPECT,
+
+	/**
+	 * Full reflection support is required, including the ability to invoke
+	 * the {@link Executable}.
+	 */
+	INVOKE;
+
+}